#include "CroppingAlgorithm.h"
#include <QDebug>
#include <QPainter>
/**
 * @brief 构造函数
 */
CroppingAlgorithm::CroppingAlgorithm(QObject *parent)
    : ImageProcessingAlgorithmBase(parent),
      m_cropRect(), // 初始为空区域，表示未启用裁剪
      m_settingsForm(nullptr),
      m_processed(false) // 初始为未处理状态
{
    // 构造函数初始化成员变量
}

/**
 * @brief 初始化算法
 * 用于注册算法widget
 */
void CroppingAlgorithm::initialize()
{
    // 创建设置表单
    m_settingsForm = new CroppingSettingsForm();
    // 初始化设置表单的裁剪区域
    m_settingsForm->setCropRect(m_cropRect);
    // 连接裁剪区域变更信号
    connect(m_settingsForm, &CroppingSettingsForm::cropRectChanged, this, &CroppingAlgorithm::setCropRect);
    connect(m_settingsForm, &CroppingSettingsForm::executeActualCrop, this, &CroppingAlgorithm::onExecuteActualCrop);
    // 发出注册widget信号
    emit registerAlgorithmWidget(algorithmName(), m_settingsForm, ":/images/images/CroppingBlue.png");
}

void CroppingAlgorithm::setInputImage(const QString &imageId, const QImage &inputImage)
{
    // 设置新图像时重置所有参数到默认值
    resetToDefaultParameters();
    m_imageId = imageId;
    m_inputImage = inputImage;
    m_settingsForm->setCropRect(QRect(0,0,inputImage.size().width(),inputImage.size().height()));
}

QString CroppingAlgorithm::currentImageId() const
{
    return m_imageId;
}

/**
 * @brief 析构函数
 */
CroppingAlgorithm::~CroppingAlgorithm()
{
    if (m_settingsForm)
    {
        m_settingsForm = nullptr;
    }
}

/**
 * @brief 图像处理核心接口
 * @param input 输入图像
 * @return 处理后的输出图像
 */
void CroppingAlgorithm::processImage(const QString& parameters)
{
    if (m_inputImage.isNull())
    {
        return;
    }
    bool isPretreatment=false;
    QStringList parameterList=parameters.split(",");
    if(parameterList.size()>=8)
    {
        m_cropRect=QRect(QPoint(parameterList[0].toUInt(),parameterList[1].toUInt()),QPoint(parameterList[6].toUInt(),parameterList[7].toUInt()));
        isPretreatment=true;
    }

    QImage outputImage= processImage(false);

    emit imageProcessed(m_imageId, outputImage,isPretreatment);
}

/**
 * @brief 执行图像裁剪预览
 * @param preview 是否为预览模式
 * @return 处理后的图像
 */
QImage CroppingAlgorithm::processImage(bool preview)
{
    if (m_inputImage.isNull()) {
        return QImage();
    }

    // 检查裁剪是否启用，如果裁剪区域为空则表示未启用裁剪
    if (m_cropRect.isEmpty()) {
        // 未启用裁剪，直接返回原始图像
        return m_inputImage;
    }

    if (!isValidCropRect(m_inputImage, m_cropRect)) {
        // 裁剪区域无效，返回原始图像
        return m_inputImage;
    }

    if (preview) {
        // 预览模式，返回带有裁剪区域标记的图像
        return markCropArea(m_inputImage, m_cropRect);
    } else {
        // 非预览模式，执行实际裁剪
        return m_inputImage.copy(m_cropRect);
    }
}

/**
 * @brief 标记裁剪区域
 * @param image 原始图像
 * @param rect 裁剪区域
 * @return 带有裁剪区域标记的图像
 */
QImage CroppingAlgorithm::markCropArea(const QImage& image, const QRect& rect)
{
    // 创建图像副本
    QImage markedImage = image.copy();
    
    // 创建绘图设备
    QPainter painter(&markedImage);
    
    // 设置半透明效果
    painter.setOpacity(0.5);
    
    // 绘制裁剪区域外的灰色遮罩
    QColor maskColor(128, 128, 128, 128); // 半透明灰色
    
    // 绘制顶部遮罩
    painter.fillRect(0, 0, markedImage.width(), rect.top(), maskColor);
    // 绘制左侧遮罩
    painter.fillRect(0, rect.top(), rect.left(), rect.height(), maskColor);
    // 绘制右侧遮罩
    painter.fillRect(rect.right() + 1, rect.top(), markedImage.width() - rect.right() - 1, rect.height(), maskColor);
    // 绘制底部遮罩
    painter.fillRect(0, rect.bottom() + 1, markedImage.width(), markedImage.height() - rect.bottom() - 1, maskColor);
    
    // 恢复不透明
    painter.setOpacity(1.0);
    
    // 绘制裁剪区域边框
    QPen pen(Qt::red, 1, Qt::SolidLine);
    painter.setPen(pen);
    painter.drawRect(rect);
    
    // 绘制裁剪区域的四个角
    int cornerSize = 10;
    // 计算矩形的实际边界
    int right = rect.left() + rect.width();
    int bottom = rect.top() + rect.height();
    // 左上角
    painter.drawLine(rect.left()+1, rect.top()+1, rect.left() + cornerSize+1, rect.top()+1);
    painter.drawLine(rect.left()+1, rect.top()+1, rect.left()+1, rect.top() + cornerSize+1);
    // 右上角
    painter.drawLine(right - 1, rect.top()+1, right - 1 - cornerSize, rect.top()+1);
    painter.drawLine(right - 1, rect.top()+1, right - 1, rect.top() + cornerSize+1);
    // 左下角
    painter.drawLine(rect.left()+1, bottom - 1, rect.left() + cornerSize+1, bottom - 1);
    painter.drawLine(rect.left()+1, bottom - 1, rect.left()+1, bottom - 1 - cornerSize);
    // 右下角
    painter.drawLine(right - 1, bottom - 1, right - 1 - cornerSize, bottom - 1);
    painter.drawLine(right - 1, bottom - 1, right - 1, bottom - 1 - cornerSize);
    
    painter.end();
    
    return markedImage;
}

/**
 * @brief 设置裁剪区域
 * @param rect 裁剪区域
 */
void CroppingAlgorithm::setCropRect(const QRect& rect)
{
    m_cropRect = rect;
    
    // 重置处理状态，确保下次调用processImage时显示预览效果
    m_processed = false;

    // 如果已经设置了输入图像，则立即处理
    if (!m_inputImage.isNull()) {
        emit imageProcessed(m_imageId, processImage(true));
    }
}

/**
 * @brief 执行实际裁剪
 * 点击确定按钮时调用，执行实际的裁剪操作
 */
void CroppingAlgorithm::onExecuteActualCrop()
{
    if (m_inputImage.isNull()) {
        return;
    }
    processImage("");
}

/**
 * @brief 获取当前裁剪区域
 * @return 裁剪区域
 */
QRect CroppingAlgorithm::cropRect() const
{
    return m_cropRect;
}

/**
 * @brief 获取算法处理参数
 * @return 包含处理参数的QVariantMap
 */
QVariantMap CroppingAlgorithm::getProcessParameters() const
{
    QVariantMap params;
    params["algorithmName"] = algorithmName();
    params["imageId"] = m_imageId;
    params["processed"] = m_processed;
    params["cropRectX"] = m_cropRect.x();
    params["cropRectY"] = m_cropRect.y();
    params["cropRectWidth"] = m_cropRect.width();
    params["cropRectHeight"] = m_cropRect.height();
    return params;
}

/**
 * @brief 检查裁剪区域是否有效
 * @param sourceImage 源图像
 * @param rect 裁剪区域
 * @return 是否有效
 */
bool CroppingAlgorithm::isValidCropRect(const QImage& sourceImage, const QRect& rect)
{
    if (sourceImage.isNull()) {
        return false;
    }

    // 检查裁剪区域是否完全在图像范围内
    return rect.x() >= 0 &&
           rect.y() >= 0 &&
           rect.right() <= sourceImage.width() &&
           rect.bottom() <= sourceImage.height() &&
           rect.width() > 0 &&
           rect.height() > 0;
}

QString CroppingAlgorithm::algorithmName() const
{
    return QString("图像裁剪");
}

void CroppingAlgorithm::setProcessParameters(const QVariantMap &params)
{
    // 检查并设置处理状态参数
    if (params.contains("processed")) {
        m_processed = params["processed"].toBool();
    }
    
    // 检查并设置裁剪区域参数
    if (params.contains("cropRectX") && 
        params.contains("cropRectY") && 
        params.contains("cropRectWidth") && 
        params.contains("cropRectHeight")) {
        
        int x = params["cropRectX"].toInt();
        int y = params["cropRectY"].toInt();
        int width = params["cropRectWidth"].toInt();
        int height = params["cropRectHeight"].toInt();
        
        QRect newCropRect(x, y, width, height);
        setCropRect(newCropRect);
    }
}

/**
 * @brief 恢复默认参数
 * 将算法的所有参数恢复到默认设置
 */
void CroppingAlgorithm::resetToDefaultParameters()
{
    // 恢复默认裁剪区域（空区域，表示未启用裁剪）
    m_cropRect = QRect();
    
    // 重置处理状态
    m_processed = false;
    
    // 清除设置的图像数据
    m_inputImage = QImage();
    m_imageId.clear();
    
    // 更新设置表单，但避免触发信号循环
    if (m_settingsForm) {
        // 断开信号连接，避免触发cropRectChanged信号
        disconnect(m_settingsForm, &CroppingSettingsForm::cropRectChanged, this, &CroppingAlgorithm::setCropRect);
        
        // 更新设置表单（空区域，表示未启用裁剪）
        m_settingsForm->setCropRect(m_cropRect);
        
        // 重新连接信号
        connect(m_settingsForm, &CroppingSettingsForm::cropRectChanged, this, &CroppingAlgorithm::setCropRect);
    }
    
    qDebug() << "CroppingAlgorithm: Reset to default parameters and cleared image data";
}
